get-the-solution

Digitale Standardbaugruppen

By
on Regards: TGI; education;

Hinweis: Abbildungen die aus externen Quellen stammen, stehen nicht unter der CC Lizenzbedingung zuverfügung, sondern unterliegen den jeweiligen Urheberrechten des Verlages!

Text aus der Reihe Technische Grundlagen der Informatik. Vorgängertext “Logische Schaltungen”. Hinweise auf Fehler, Verbesserungsvorschläge gerne per Email oder per PR auf die .md File.

Digitale Standardbaugruppen

Standardbaugruppen implementierten standardisierte Grundschaltungen. Das sind immer wiederkehrende Grundschaltungen wie z.B. die des Halbaddierers, Encoders, Komperators und so weiter. Wenn man beispielsweise einen Halbaddierer in seiner eigenen Schaltung benötigt, der wie oben erwähnt zu den digitalen Standardabaugruppen gehört, reicht es nur noch das Ersatz Schaltbild zu zeichnen, da die Funktion jedem bekannt ist.

Wie diese Funktionen implementiert sein können wird in den nächsten Abschnitten beschrieben. Wenn man weiß, welchen Zweck der Standardbaustein erfüllt reicht es in den meisten Fällen aus die Funktion her zu leiten oder eine Wahrheitstabelle auf zu stellen. Die dabei erstellte logische Schaltung die der Standardbaustein implementiert wäre dann die standardisierte Grundschaltung.

Encodierer

Ein Encodierer (oder Codierer) verdichtet Informationen in dem er bei n Eingängen am Ausgang die Bitfolge angibt, welcher der Eingänge aktiv ist. Beim Codierer darf nur ein Eingang aktiv sein! Ein Codierer mit n Eingängen hat genau log_2(n)=m Ausgänge (vgl. Schildt, Einführung in die technische Informatik, S. 20-21).

E7 E6 E5 E4 E3 E2 E1 E0 A2 A1 A0
0 0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 1 0 0 0 1
0 0 0 0 0 1 0 0 0 1 0
0 0 0 0 1 0 0 0 0 1 1
0 0 0 1 0 0 0 0 1 0 0
0 0 1 0 0 0 0 0 1 0 1
0 1 0 0 0 0 0 0 1 1 0
1 0 0 0 0 0 0 0 1 1 1

Ein Codierer mit 8 Eingängen hat also 3 Ausgänge (ld(8)=3). Ist nun der Eingang E4 aktiv gibt er die Binärzahl 1002 aus was im Dezimal der Zahl 4 entspricht. Die Funktion der drei Ausgänge lautet

A0=e1+e3+e5+e7

A1=e2+e3+e6+e7

A2=e4+e5+e6+e7

Abb. 7 Codierer mit 8 Eingängen

Die Schaltung kann somit mit drei OR Gatter realisiert werden. Der Schalter e7 ist in der obigen Abbildung aktiv und die Schaltung gibt in Form von 3 aktiven Glühbirnen die binäre Zahl 1112 = 7 aus. Der Schalter e0 hätte man auch mit einem log 0 verbinden können da bei e0 nie „1“ ausgegeben wird.

Es besteht in dieser Form aber noch das Problem, dass theoretisch mehr als nur ein Eingang aktiv sein kann. Dies führt zu falschen Ausgaben.

Abb. 8 Codierer

Um dies zu verhindern wurde der sogenannte Valid Ausgang, der angibt ob die Ausgabe gültig ist, eingeführt. Sobald mehr als ein Eingang aktiv ist, gibt er 0 für not Valid aus und 1 für Valid, womit man erkennt ob die Ausgabe gültig ist. Da nur das höchstwertige Bit im Eingang zählt sind alle dahinterliegenden Bits als „don’t cares“ gesetzt. Man spricht dann auch von einem Priority Encoder.

E7 E6 E5 E4 E3 E2 E1 E0 A2 A1 A0 V
0 0 0 0 0 0 0 1 0 0 0 0
0 0 0 0 0 0 1 X 0 0 1 1
0 0 0 0 0 1 X X 0 1 0 1
0 0 0 0 1 X X X 0 1 1 1
0 0 0 1 X X X X 1 0 0 1
0 0 1 X X X X X 1 0 1 1
0 1 X X X X X X 1 1 0 1
1 X X X X X X X 1 1 1 1

Um die Schaltfunktion mit dem Validbit Ausgang zu realisieren würde man eine 2^8 also eine Wahrheitstabelle mit 256 Zeilen benötigen. Das dazugehörige KV-Diagramm wäre dafür zu unübersichtlich, deshalb spalten wird die Eingänge in jeweils 2 Gruppen E0-E3 und E4-E7 auf. Der Valid Ausgang darf nur dann 1 ausgeben, wenn nur ein Eingang logisch 1 ist. Somit ergibt sich für die Eingänge E0-E3 folgende Wahrheitstabelle.

E0 E1 E2 E3 V
0 0 0 0 0
0 0 0 1 1
0 0 1 0 1
0 0 1 1 0
0 1 0 0 1
0 1 0 1 0
0 1 1 0 0
0 1 1 1 0
1 0 0 0 1
1 0 0 1 0
1 0 1 0 0
1 0 1 1 0
1 1 0 0 0
1 1 0 1 0
1 1 1 0 0
1 1 1 1 0

KV Diagramm

!e4 e4 E4 !e4
!e3 0 0 0 1 e2
e3 0 0 0 0 e2
e3 0 0 0 1 !e2
!e3 1 0 1 0 !e2
e1 e1 !e1 !e1

Aus dem KV Diagramm liest man dann folgende Funktion V(E0,E1,E2,E3)=!e1.e2.!e3.!e4+!e1.!e2.e3.!e4+!e1.!e2.!e3.e4+e1.!e2.!e3.!e4

Daraus lässt sich ableiten, dass die Funktion mit 8 Eingängen wie folgt aussieht.

V(E0,E1,E2,E3,E4,E5,E6,E7)=e0.!e1.!e2.!e3.!e4.!e5.!e6.!e7+ !e0.e1.!e2.!e3.!e4.!e5.!e6.!e7+ !e0.!e1.e2.!e3.!e4.!e5.!e6.!e7+!e0.!e1.!e2.e3.!e4.!e5.!e6.!e7+!e0.!e1.!e2.!e3.e4.!e5.!e6.!e7+ !e0.!e1.!e2.!e3.!e4.e5.!e6.!e7+!e0.!e1.!e2.!e3.!e4.!e5.e6.!e7+!e0.!e1.!e2.!e3.!e4.!e5.!e6.e7

Die Schaltung um die Valid Funktion sieht dann wie folgt aus.

Abb. 9 Codierer mit Valid Funktion

Für den Encoder wird vereinfachend folgendes Symbol verwendet.

Abb. 10 Codierer

Decodierer

Der Decoder ist das Gegenstück zum Encoder. Über den Eingang kann angegeben werden, auf welcher Ausgangsleitung ein aktives Signal „hinausgeschickt“ werden soll. Oder anders gesagt, ein Ausgang geht genau dann auf logisch 1, wenn die Binärzahl, die am Eingang anliegt, gleich seiner Nummer i ist (Schildt, Einführung in die technische Informatik, S. 21). Damit das Bauelement aktiv werden kann, gibt es einen Enable Eingang. Solange der Enable Eingang 0 ist bleiben die Ausgänge 0. Daraus ergibt sich folgende Wahrheitstabelle:

Mit zwei Eingängen kann man 2^2 Ausgänge bedienen.

E E1 E2 A3 A2 A1 A0
0 X X 0 0 0 0
1 0 0 0 0 0 1
1 0 1 0 0 1 0
1 1 0 0 1 0 0
1 1 1 1 0 0 0

Die Schaltungsfunktion kann mit AND Gatter implementiert werden, in dem man schrittweise für jeden Ausgang die Funktion realisiert. Die Funktionen für die Ausgänge lauten:

A0(E1,E2,E)= !E1.!E2.E

A1(E1,E2,E)=!E1.E2.E

A2(E1,E2,E)=E1.!E2.E

A3(E1,E2,E)=E1.E2.E

Am Eingang liegt durch das Umkippen beider Schalter 112 an, was der Zahl 3 im Dezimal entspricht. Die Schaltungsfunktion gibt am Ausgang mit der Nummer 3 eins aus.

Abb. 11 “2 zu 4 Decoder”

Dieser 2 zu 4 Decoder können wir auch mit folgendem Blockschaltbild darstellen:

Abb. 12 “2 zu 4 Decoder”

Durch das Hintereinanderschalten mehrerer Decoder kann man die Eingangs- sowie die Ausgangsanzahl des Decoders erhöhen. Im folgenden Beispiel wird aus einem 2 to 4 Decoder ein 4 to 16 Decoder gebaut.

Abb. 13 “4 zu 16 Decoder”

Bei der Eingabe der binären Zahl 0101_2 wird der Ausgang mit der Nummer a5 aktiv.

Abb. 14 “4 zu 16 Decoder”
E E3 E2 E1 E0 A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15
0 X X X X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0
1 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0
1 0 1 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1

Multiplexer

Ein Multiplexer bzw. MUX ist eine Erweiterung des Codierers (vgl. Schildt, Einführung in die technische Informatik, S. 22). Mit ihm ist es möglich zu bestimmen welche Eingangssignale zum Ausgang weitergeleitet werden sollen. Über das Steuersignal wählt man den jeweiligen Eingang aus.

Da die meisten Informationen mehr als nur 1 Bit lang sind, werden die zusammengehörigen Eingangssignale durch Indizes zusammengefasst. Zusammengehörige binäre Informationen werden auch Codewort genannt. (vgl. Schildt, Einführung in die technische Informatik, S. 23). Das heißt, dass das Steuersignal bestimmt welche der zusammengefassten Eingänge bzw. welches Codewort durchgeschalten wird. Über die Anzahl der Ausgangsleitungen beim MUX lässt sich ablesen aus wie vielen Bit ein Codewort besteht.

Über log_2(Anzahl der Codewörter) erhält man die Anzahl der erforderlichen Steuerleitungen. Zum Beispiel braucht man bei 4 Eingängen 2 Steuersignale um diese zu „adressieren“, da man mit 2 Steuerleitungen 2^2 Adressierungen durchführen kann. Das MUX verfügt wie die bereits vorgestellten Bauelemente über einen Enable Eingang um festzulegen, wann Informationen durchgeschalten werden sollen.

Im Folgenden wollen wir einen 4 to 1 MUX entwerfen. Wir haben 4 Eingänge von denen einer je nach Steuersignal zum Ausgang durchgeschalten wird. Um jeweils einen der 4 Eingänge auswählen zu können benötigen wir 2 Steuereingänge. Daraus ergibt sich folgende Wahrheitstabelle:

E S0 S1 A
(0 X X 0)
1 0 O E0
1 0 1 E1
1 1 0 E2
1 1 1 E3

A(E,S0,S1,E0,E1,E2,E3)=!S0.!S1.E0.E + !S0.S1.E1.E + S0.!S1.E2.E + S0.S1.E3.E

Abb. 16 “4 to 1 MUX”
Abb. 15 “4 to 1 MUX”

Da beim Steuereingang die Kombination 102 anliegt wird der Eingang E2 durchgeschaltet. Da aktuell der Schalter gekippt ist wird die 1 am Ausgang ausgegeben. Genauso würde auch eine logische 0 (Schalter nicht gekippt) zum Ausgang weitergeleitet werden, würde diese am zweiten Eingang anliegen.

Es gibt beliebige MUX Varianten, das folgende Abbild stellt ein 2 to 1 MUX deren Codebreite 4 Bit beträgt, dar. Das bedeutet, dass 2 Eingänge also E1 und E2 vorhanden sind, wobei ein Eingang über eine 4 Bit Wortbreite verfügt. Der erste Eingang ist an der Indexnummer 1.x erkennbar.

Abb. 17 “2 to 1 MUX deren Codebreite 4 Bit”
Abb. 18 “2 to 1 MUX deren Codebreite 4 Bit”

Wie mit allen anderen Bausteinen kann man diese gegenseitig kombinieren und neue Varianten kreieren. Einen 8 to 1 MUX kann man z.B. mit zwei 4 to 1 MUX und mit einem verknüpfenden 2 to 1 MUX bauen.

Abb. 19 “8 to 1 MUX”

Demultiplexer

Ein Demultiplexer ist das analoge Gegenstück zum MUX. Mit ihm ist es möglich ein Eingangssignal durch die Steuerleitungen auf einen bestimmten Ausgang weiterzuleiten. Die Anzahl der Steuerleitungen ist hier abhängig von der Anzahl der Ausgänge. Oder anders gesagt, mit n Steuerleitungen kann man 2n Ausgänge ansteuern.

Um die Schaltung des Demultiplexer zu realisieren erstellen wir wieder eine Wahrheitstabelle.

E S0 S1 E0 A0 A1 A2 A3
(0 X X X 0 0 0 0)
1 0 O X E0 0 0 0
1 0 1 X 0 E0 0 0
1 1 0 X 0 0 E0 0
1 1 1 X 0 0 0 E0

A0(E,S0,S1,E)=!S0.!S1.E0.E

A1(E,S0,S1,E)=!S0.S1.E0.E

A2(E,S0,S1,E)=S0.!S1.E0.E

A3(E,S0,S1,E)=S0.S1.E0.

Man erkennt hier, dass die Ausgangsfunktionen der eines Decoders entsprechen. Folgendes Einsatzszenario lässt sich vorstellen: man soll über die Steuerleitung bestimmen können, welche Rechenoperation auf das Eingangssignal durchgeführt werden soll. Am Ausgang hängt man dann, je nach definierter Operation, das jeweilige Hardwareelement an. Wie bei dem Multiplexer ist es auch hier wieder möglich, dass der Eingang über eine höhere Wortbreite wie nur 1 Bit verfügt.

Mit dem Multiplexer und dem Demultiplexer stehen uns zwei Standardschaltnetze zur Verfügung mit deren Hilfe sich der Datenfluss innerhalb einer Hardware-Schaltung auf einfache Weise steuern lässt (dirk w. HOFFMANN, Grundlagen der Technischen Informatik 3 Auflage, Hanser, S. 206).

Halbaddierer

Wir wollen mit dem Halbaddierer eine Funktion implementieren mit der es möglich ist über die Eingangssignale Binärzahlen zu addieren. Dazu stellen wir folgende Wahrheitstabelle auf:

Input e1+e2
e1 e2 carry sum
0 0 0 0
0 1 0 1
1 0 0 1
1 1 1 0

Da es bei der Addition der Zahl 1+1 zu einem Übertrag kommen kann, müssen wir zusätzlich einen Carry Ausgang zum Gatter hinzufügen.

Anhand der Wahrheitstabelle erkennt man, dass der Carry Ausgang mit einem AND Gatter und der Sum Ausgang mit einem XOR Gatter realisiert werden kann.

Abb. 20 “HA”

Um nicht immer die komplette Schaltung des Halbaddierers zeichnen zu müssen, kann man vereinfachend folgendes Symbol verwenden:

Abb. 21 “HA”

Möchte man zwei-bitige Zahlen addieren, benötigt man einen erweiterten Addierbaustein. Außerdem soll dieser erweiterte Addierbaustein hintereinander schaltbar sein. Dazu wird ein weiterer Eingang benötigt der den Übertrag der vorherigen Rechnung mit berücksichtigt. Ein Baustein mit dieser Fähigkeit nennt man auch Volladdierer.

Abb. 22 “HA”

Im obigen Schaltbild sieht man die Implementation eines Volladdieres. Der erste Halbaddierer berechnet das Ergebnis von e1 und e2. Dieses Ergebnis wird dann noch mit dem Carry Eingang addiert. Ein Volladdierer kann also durch zwei Halbaddierer die mit einem OR Gatter verknüpft sind realisiert werden. Das vollständige Schaltbild eines Volladdierers sieht folgendermaßen aus:

Abb. 23 “HA”

Daraus ergibt sich folgende Wahrheitstabelle für den Full Adder:

e1 e2 ci-1 ci sum
0 0 0 0 0
0 0 1 0 1
0 1 0 0 1
0 1 1 1 0
1 0 0 0 1
1 0 1 1 0
1 1 0 1 0
1 1 1 1 1

Im nachfolgenden Beispiel soll die Rechenoperation A+B oder –A+B, welche im Zweierkomplement und 4 Bit lang sind, mit logischen Bausteinen realisiert werden.

Bei einer Addition können die Zahlen ganz normal mit einem Addierer Baustein durchgeführt werden. Bei der Subtraktion –A+B muss die Zahl A negativ gemacht werden. Dies wird erreicht indem man diese Zahl ins Zweierkomplement bringt. Dazu werden sämtliche Bits der Zahl B invertiert und das LSB, also die letzte Stelle, mit +1 addiert. Anschließend kann man die Zahlen addieren, um die Subtraktion auszuführen.

Abb. 24 “HA”

Die Schaltung verfügt über 9 Eingänge, wobei 2 Eingänge für die Zahl A und B bestimmt sind, über den letzten Schalter kann man bestimmen, ob man eine Addition oder eine Subtraktion durchführen will. Von den Eingängen der Zahl A lässt sich über einen Demultiplexer auswählen, ob man das invertierte Bit oder unveränderte Bit vom Eingang auswählen will. Der Demultiplexer wird über den Eingang des Add/Sub Schalters gesteuert. Die gleichwertigen Stellen der Zahl A und B werden dann mit dem Fulladder zusammengezählt und ausgegeben.

Der erste Fulladder ist beim ci-1 Eingang mit dem Add/Sub Eingang verbunden. Will man addieren, liegt am ci-1 Eingang eine 0 an, d.h. die Zahlen A und B bleiben unverändert. Beim Subtrahieren liegt eine 1 an.

Damit wird zur niederwertigsten Stelle eine 1 addiert um die Zahl A vom Einerkomplement, was durch die Demultiplexer geschieht, ins Zweierkomplement gebracht. In der obigen Schaltung liegt am Eingang A die Zahl 01102?6 und am Eingang B die Zahl 01002? 4 an und der Rechenoperationsschalter ist auf Subtraktion gesetzt. Das heißt es wird -6+4 =-2 berechnet. Der Eingang der Zahl A wird zunächst invertiert 01102?10012. Zum Schluss werden über die Fulladder die Zahlen addiert.

1001
1
+ 0100
1110
0010 ?2
1101 Invertieren
+ 0001 +1
1110 ?-2

Wir kontrollieren das Ergebnis indem wir die Dezimalzahl -2 im binären Zweierkomplement darstellen und das Ergebnis der Schaltung vergleichen (01110).

Addierer können miteinander kombiniert werden um die Bitbreite der zu addierenden Zahl zu vergrößern. Es gibt verschiedene Addierervarianten wie den Carry-Ripple Addierer, Look Ahead Addierer die auf die Ausführungszeit hin optimiert wurden. (Mehr Informationen siehe dazu in der Literatur Dirk W. Hoffmann, Grundlagen der Technischen Informatik, S. 218.)

Komperator

Ein Komperator wird verwendet um zwei Eingangssignale zu vergleichen. Komplexere Komperatoren verfügen noch über die Möglichkeit Eingangsignale auf Gleichheit, größer oder kleiner zu prüfen. Dies könnte z.B. durch einen MUX realisiert werden. Über das Steuersignal gibt man an, worauf die beiden Eingangssignale verglichen werden sollen. Wir beschränken uns fürs Erste auf das erste einfachere Szenario.

Der folgende Komperator vergleicht zwei Zahlen die ein Bit breit sind. Sind die Zahlen gleich, wird 1 ausgeben.

e1 e2 =
0 0 1
0 1 0
1 0 0
1 1 1

Anhand der Funktionsausgabe erkennt man, dass die Schaltung mit einem XNOR realisiert werden kann. Wir fügen noch einen Enable Eingang hinzu und erhalten somit folgende Schaltung:

Abb. 25 “Komperator”
Abb. 26 “Komperator”

Wenn jeweils das Codewort zwei Bit breit ist, kann man mithilfe des Ersatzschaltbildes die Wortbreite des Komperators vergrößern (in der folgenden Abbildung mit einer Wortbreite von zwei Bit dargestellt). Die Wortbreite lässt sich analog zur unteren Schaltung vergrößern.

Abb. 27 “Komperator”

Quellen

  • dirk w. HOFFMANN, Grundlagen der Technischen Informatik 3 Auflage, Hanser
  • Schildt, Einführung in die technische Informatik